// const db = require('../config/mysql.js')
const WarehousingModel = require('../model/WarehousingModel.js')
const fs = require('fs');
const path = require('path');

// ES6 Class - 推荐
class WarehousingController {
    constructor() {
        this.warehousingModel = new WarehousingModel();
    }
    async getInventoryinList(req, res) {
        // 获取查询参数
        const queryParams = req.query;
        console.log('查询参数:', queryParams)

        // 调用model层方法,获取数据，并传递查询参数
        const result = await this.warehousingModel.getInventoryinList(queryParams);
        // 返回数据
        let data = {
            code: 0, // 0:成功，1:失败
            msg: 'success', // 成功或失败信息
            data: result // 数据
        }
        res.json(data)
    }
    // 根据采购订单的id获取采购订单详情
    async GetGoodsOrderDetail(req, res) {
        // 获取查询参数
        const queryParams = req.query.order_id;
        console.log('查询参数:', queryParams)

        // 调用model层方法,获取数据，并传递查询参数
        const result = await this.warehousingModel.GetGoodsOrderDetail(queryParams);
        // 返回数据
        let data = {
            code: 0, // 0:成功，1:失败
            msg: 'success', // 成功或失败信息
            data: result // 数据
        }
        res.json(data)
    }


    // 根据id获取订单详情
    async GetInventoryinDetail(req, res) {
        // 获取查询参数
        const queryParams = req.query.code;
        console.log('查询参数:', queryParams)

        // 调用model层方法,获取数据，并传递查询参数
        const result = await this.warehousingModel.GetInventoryinDetail(queryParams);
        // 返回数据
        let data = {
            code: 0, // 0:成功，1:失败
            msg: 'success', // 成功或失败信息
            data: result // 数据
        }
        res.json(data)
    }
    // 根据用户ID来获取用户名
    async GetUserName(req, res) {
        // 获取查询参数
        const queryParams = req.query.user_id;
        console.log('查询参数:', queryParams)

        // 调用model层方法,获取数据，并传递查询参数
        const result = await this.warehousingModel.GetUserName(queryParams);
        // 返回数据
        let data = {
            code: 0, // 0:成功，1:失败
            msg: 'success', // 成功或失败信息
            data: result // 数据
        }
        res.json(data)
    }

    // 添加入库记录
    async AddInventoryin(req, res) {
        try {
            // 获取请求体参数
            const bodyParams = req.body;
            console.log('请求体参数:', bodyParams)
            if (req.files && req.files.in_doc_pic) {
                const file = req.files.in_doc_pic;

                // 检查文件大小 (5MB限制)
                if (file.size > 5 * 1024 * 1024) {
                    return res.status(400).json({ code: 1, msg: '文件大小超过限制（最大5MB）' });
                }

                // 检查MIME类型
                const allowedImageTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp'];
                if (!allowedImageTypes.includes(file.mimetype)) {
                    return res.status(400).json({ code: 1, msg: '只允许上传图片文件 (jpg, jpeg, png, gif, bmp)' });
                }

                // 检查文件扩展名
                const allowedImageExtensions = /\.(jpg|jpeg|png|gif|bmp)$/i;
                if (!allowedImageExtensions.test(file.name)) {
                    return res.status(400).json({ code: 1, msg: '只允许上传图片文件 (jpg, jpeg, png, gif, bmp)' });
                }

                // 生成唯一文件名以防止文件名冲突
                const timestamp = Date.now();
                const randomString = Math.random().toString(36).substring(2, 15);
                const fileExtension = path.extname(file.name);
                const uniqueFileName = `${timestamp}-${randomString}${fileExtension}`;

                // 确保上传目录存在
                const uploadDir = path.join("public", "uploads");
                if (!fs.existsSync(uploadDir)) {
                    fs.mkdirSync(uploadDir, { recursive: true });
                }

                const uploadPath = path.join(uploadDir, uniqueFileName); //存储路径
                const showPath = "static/uploads/" + uniqueFileName;

                // 记录文件上传时间
                const startTime = new Date();
                console.log(`开始上传收据文件: ${uniqueFileName} at ${startTime}`);

                // 移动文件到指定位置
                await file.mv(uploadPath);

                const endTime = new Date();
                const uploadDuration = (endTime - startTime) / 1000; // 转换为秒
                console.log(`收据文件上传成功: ${uniqueFileName}, 用时: ${uploadDuration}s, 大小: ${file.size} bytes`);

                // 保存文件路径到数据库
                bodyParams.in_doc_pic = showPath;
            }

            // 调用model层方法,新增数据，并传递请求体参数
            const result = await this.warehousingModel.AddInventoryin(bodyParams);
            // 返回数据
            let data = {
                code: 0, // 0:成功，1:失败
                msg: 'success', // 成功或失败信息
                data: result // 数据
            }
            res.json(data)
        } catch (error) {
            console.error('添加入库记录时发生错误:', error);
            // 返回错误响应
            res.status(500).json({
                code: 1, // 1:失败
                msg: error.message || '添加入库记录失败',
                data: null
            })
        }
    }
    // 添加入库详情
    async AddInventoryinItem(req, res) {
        console.log(1)
        try {
            console.log(2)
            // 获取请求体参数
            const bodyParams = req.body;
            console.log('请求体参数:', bodyParams)

            // 调用model层方法,新增数据，并传递请求体参数
            const result = await this.warehousingModel.AddInventoryinItem(bodyParams);
            // 返回数据
            let data = {
                code: 0, // 0:成功，1:失败
                msg: 'success', // 成功或失败信息
                data: result // 数据
            }
            console.log(4)
            res.json(data)
        } catch (error) {
            console.log(3)
            console.error('添加入库记录时发生错误:', error);
            // 返回错误响应
            res.status(500).json({
                code: 1, // 1:失败
                msg: error.message || '添加入库记录失败',
                data: null
            })
        }
    }

    // 查询对应的商品信息
    async GetGoodsOrder(req, res) {
        try {
            const id = req.params.id;
            console.log('请求参数:', id)

            // 调用model层方法,新增数据，并传递请求体参数
            const result = await this.warehousingModel.GetGoodsOrder(id);
            // 返回数据
            let data = {
                code: 0, // 0:成功，1:失败
                msg: 'success', // 成功或失败信息
                data: result // 数据
            }
            res.json(data)
        } catch (error) {
            console.error('添加入库记录时发生错误:', error);
            // 返回错误响应
            res.status(500).json({
                code: 1, // 1:失败
                msg: error.message || '添加入库记录失败',
                data: null
            })
        }
    }


    async UpdateInventoryin(req, res) {
        try {
            // 获取请求体参数
            const bodyParams = req.body;
            const id = req.params.id;
            console.log('请求体参数:', bodyParams)

            // 调用model层方法,新增数据，并传递请求体参数
            const result = await this.warehousingModel.UpdateInventoryin(bodyParams, id);
            // 返回数据
            let data = {
                code: 0, // 0:成功，1:失败
                msg: 'success', // 成功或失败信息
                data: result // 数据
            }
            res.json(data)
        } catch (error) {
            console.error('修改入库记录时发生错误:', error);
            // 返回错误响应
            res.status(500).json({
                code: 1, // 1:失败
                msg: error.message || '修改入库记录失败',
                data: null
            })
        }
    }
    async DeleteInventoryin(req, res) {
        try {
            // 获取请求体参数
            const id = req.params.id;
            // 调用model层方法,新增数据，并传递请求体参数
            const result = await this.warehousingModel.DeleteInventoryin(id);
            // 返回数据
            let data = {
                code: 0, // 0:成功，1:失败
                msg: 'success', // 成功或失败信息
                data: result // 数据
            }
            res.json(data)
        } catch (error) {
            console.error('删除入库记录时发生错误:', error);
            // 返回错误响应
            res.status(500).json({
                code: 1, // 1:失败
                msg: error.message || '删除入库记录失败',
                data: null
            })
        }
    }
    async aaa(req, res) {
        console.log(1)
        // try {
        //     // 获取请求体参数
        //     const bodyParams = req.body;
        //     console.log('请求体参数:', bodyParams)

        //     // 调用model层方法,新增数据，并传递请求体参数
        //     const result = await this.warehousingModel.aaa(bodyParams);
        //     // 返回数据
        //     let data = {
        //         code: 0, // 0:成功，1:失败
        //         msg: 'success', // 成功或失败信息
        //         data: result // 数据
        //     }
        //     res.json(data)
        // } catch (error) {
        //     console.error('添加入库详情时发生错误:', error);
        //     // 返回错误响应
        //     res.status(500).json({
        //         code: 1, // 1:失败
        //         msg: error.message || '添加入库详情失败',
        //         data: null
        //     })
        // }
    }
}

// 导出UsersController类
module.exports = WarehousingController;